home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 1.iso / toolbox / src / demos / OpenGL / space / god.c < prev    next >
C/C++ Source or Header  |  1996-11-11  |  36KB  |  1,214 lines
  1. /*
  2.  * Copyright (C) 1992, 1993, 1994, Silicon Graphics, Inc.
  3.  * All Rights Reserved.
  4.  *
  5.  * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
  6.  * the contents of this file may not be disclosed to third parties, copied or
  7.  * duplicated in any form, in whole or in part, without the prior written
  8.  * permission of Silicon Graphics, Inc.
  9.  *
  10.  * RESTRICTED RIGHTS LEGEND:
  11.  * Use, duplication or disclosure by the Government is subject to restrictions
  12.  * as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
  13.  * and Computer Software clause at DFARS 252.227-7013, and/or in similar or
  14.  * successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
  15.  * rights reserved under the Copyright Laws of the United States.
  16.  */
  17. #include "space.h"
  18.  
  19. extern char   StarName[NUMBER_OF_STARS][16] ;
  20.  
  21. extern char  mem_col_nme[32] ;
  22. extern char  mem_ele_nme[32] ;
  23. extern char *mem_col_ptr ;
  24. extern char *mem_ele_ptr ;
  25. extern t_stopwatch Counter ;
  26.  
  27. static sint32 already_count = 0 ;
  28.  
  29. static struct  {
  30.     char    name[32] ;
  31.     sint32  texdf ;
  32. } already[64] ;
  33.  
  34. #include "sol.h" 
  35.  
  36. static long check_data_file(char *);
  37.  
  38. /**********************************************************************
  39. *  create_solar_system()  -
  40. ***********************************************************************/
  41. t_system *create_solar_system(sint32 index,t_boss *flaggs,t_galaga *ga)
  42.  
  43. {  register t_system *planet,*moon ;
  44.    register sint32   i,j,k ;
  45.    register t_body   *tb,*tc ;
  46.  
  47.    flaggs->plan_current = -1;
  48.    flaggs->moon_current = -1;
  49.    flaggs->suun_current = -1;
  50.  
  51.    flaggs->plan_old = -1;
  52.    flaggs->moon_old = -1;
  53.    flaggs->suun_old = -1;
  54.  
  55.    generate_solar_system(flaggs,index,&ga->stars[index]) ;
  56.  
  57.    for (k=0; k<flaggs->suncount; k++)  {
  58.      for (planet=flaggs->star[k].ptr->moons,i=0; i<flaggs->star[k].ptr->moon_count; planet++,i++)  {
  59.        flaggs->star[k].next[i] = tb = (void *) malloc(sizeof(t_body)) ;
  60.  
  61.        tb->ptr = planet ;
  62.        create_one(tb,0.0) ;
  63.  
  64.        for (moon=planet->moons,j=0; j<planet->moon_count; moon++,j++)  {
  65.          tb->next[j] = tc = (void *) malloc(sizeof(t_body)) ;
  66.   
  67.          tc->ptr = moon ;
  68.          create_one(tc,tb->ptr->apo) ;
  69.          }
  70.        }
  71.      }
  72.  
  73.    Counter.flags |= REGEN_FLAG ;
  74. }
  75.  
  76. /**********************************************************************
  77. *  destroy_solar_system()  -
  78. ***********************************************************************/
  79. void destroy_solar_system(t_boss *flaggs)
  80.  
  81. {  register sint32   i,j,k ;
  82.    register t_body   *tb,*tc ;
  83.  
  84.    printf("Destroy Star\n") ;
  85.  
  86.    flaggs->plan_current = -1 ;
  87.    flaggs->moon_current = -1 ;
  88.    flaggs->suun_current = -1 ;
  89.  
  90.    flaggs->plan_old = -1 ;
  91.    flaggs->moon_old = -1 ;
  92.    flaggs->suun_old = -1 ;
  93.  
  94.    for (k=0; k<flaggs->suncount; k++)  {
  95.      for (i=0; i<flaggs->star[k].ptr->moon_count; i++)  {
  96.        tb = (t_body *) flaggs->star[k].next[i] ;
  97.  
  98.        for (j=0; j<tb->ptr->moon_count; j++)  {
  99.          tc = (t_body *) tb->next[j] ;
  100.          destroy_one(tc) ;
  101.          free(tc) ;
  102.          }
  103.  
  104.        destroy_one(tb) ;
  105.        free(tb) ;
  106.        }
  107.  
  108.      destroy_one(&flaggs->star[k]) ;
  109.      }
  110. }
  111.  
  112. /**********************************************************************
  113. *  scan_star_system()  - 
  114. **********************************************************************/
  115. void scan_star_system(t_boss *flaggs)
  116.  
  117. {  register flot32   d,D,dmin,angle ;
  118.    register sint32   i,k,r,g,b ;
  119.    register t_body   *tb,*tc,*sptr ;
  120.    register D3       p ;
  121.    register V3       v ;
  122.  
  123.    Counter.flags &= ~FRACT_FLAG ;
  124.    Counter.flags &= ~RINGW_FLAG ;
  125.    Counter.flags &= ~ECLIP_FLAG ;
  126.  
  127.    flaggs->plan_old = flaggs->plan_current ;
  128.    flaggs->moon_old = flaggs->moon_current ;
  129.    flaggs->suun_old = flaggs->suun_current ;
  130.  
  131.    flaggs->plan_current = -1 ; 
  132.    flaggs->moon_current = -1 ;
  133.    flaggs->suun_current = -1 ;
  134.  
  135.    for (dmin=1.0e20,k=0; k<flaggs->suncount; k++)  {
  136.      tb = &flaggs->star[k];
  137.  
  138.      p.x = 0.0;
  139.      p.y = 0.0;
  140.      p.z = 0.0;
  141.      calc_posit(&flaggs->star[k].posit,tb->ptr,&p,0.0) ;
  142.      flaggs->star[k].posit.x -= Counter.eye.x;
  143.      flaggs->star[k].posit.y -= Counter.eye.y;
  144.      flaggs->star[k].posit.z -= Counter.eye.z;
  145.  
  146.      d = sqrt(flaggs->star[k].posit.x*flaggs->star[k].posit.x +
  147.               flaggs->star[k].posit.y*flaggs->star[k].posit.y +
  148.               flaggs->star[k].posit.z*flaggs->star[k].posit.z) ;
  149.  
  150.      flaggs->star[k].distan = d ;
  151.      flaggs->star[k].angsiz = flaggs->star[k].ptr->rad/d ;
  152.  
  153.      if (d <= flaggs->star[k].ptr->rad && Counter.click != 0)  {
  154.        spRingBell() ;
  155.        printf("You Crashed Into The Sun And Vaporized!!\n") ;
  156.        if ((Counter.alpha & HW_SOUND) && (Counter.flags & SOUND_FLAG))
  157.          sound_control(1,SND_BUTT) ;
  158.        exit(0) ;
  159.        }
  160.  
  161.      if (d < dmin)  {
  162.        dmin = d ;
  163.        flaggs->suun_current = k ;
  164.        }
  165.      }
  166.  
  167.    sptr = &flaggs->star[flaggs->suun_current] ;
  168.  
  169.    for (dmin=1.0e20,k=0; k<flaggs->suncount; k++)  {
  170.      for (i=0; i<flaggs->star[k].ptr->moon_count; i++)  {
  171.        tb = (t_body *) flaggs->star[k].next[i] ;
  172.  
  173.        calc_posit(&p,tb->ptr,&flaggs->star[k].posit,0.0) ;
  174.  
  175.        tb->posit = p ; 
  176.  
  177.        d = fsqrt(p.x*p.x+p.y*p.y+p.z*p.z) ;
  178.  
  179.        tb->distan = d ;
  180.        tb->orbsiz = tb->ptr->orb/d ;
  181.  
  182.        if (((tb->ptr->tess >> 4) & 0x0f) == FRAC_RINGWO) 
  183.          tb->angsiz = tb->ptr->orb/d ;
  184.        else tb->angsiz = tb->ptr->rad/d ;
  185.  
  186.        if (d <= tb->ptr->rad && Counter.click != 0)  {
  187.          spRingBell() ;
  188.          Counter.eye.x -= (12.0 + tb->ptr->rad - d) * p.x/d;
  189.          Counter.eye.y -= (12.0 + tb->ptr->rad - d) * p.y/d;
  190.          Counter.eye.z -= (12.0 + tb->ptr->rad - d) * p.z/d;
  191.          }
  192.  
  193.        if (tb->angsiz < ANGULAR_SIZE)  {
  194.          v.x = p.x - sptr->posit.x ;
  195.          v.y = p.y - sptr->posit.y ;
  196.          v.z = p.z - sptr->posit.z ;
  197.          D = fsqrt(v.x*v.x+v.y*v.y+v.z*v.z) ;
  198.          angle = (v.x*p.x + v.y*p.y + v.z*p.z) / (d*D) ;  
  199.          angle = 0.5 * (1.0 + angle) ;
  200.   
  201.          r = (tb->ptr->col >>  0) & 0xff ;
  202.          g = (tb->ptr->col >>  8) & 0xff ;
  203.          b = (tb->ptr->col >> 16) & 0xff ;
  204.          r = (float) r * angle ;
  205.          g = (float) g * angle ;
  206.          b = (float) b * angle ;
  207.          tb->color = 0xff000000 | (b<<16) | (g<<8) | r ;
  208.          }
  209.   
  210.        if (k == flaggs->suun_current && d < dmin)  {
  211.          dmin = d ;
  212.          flaggs->plan_current = i ;
  213.          }
  214.        }
  215.      }
  216.  
  217.    if (flaggs->plan_current < 0)
  218.      return;
  219.  
  220.    tb = (t_body *) sptr->next[flaggs->plan_current] ;
  221.  
  222.    Counter.light_vector.x = sptr->posit.x - tb->posit.x ;
  223.    Counter.light_vector.y = sptr->posit.y - tb->posit.y ;
  224.    Counter.light_vector.z = sptr->posit.z - tb->posit.z ;
  225.    Counter.light_angle = 180.0 + RTOD * fatan2(Counter.light_vector.x,Counter.light_vector.z) ;
  226.  
  227.    if (flaggs->plan_old != flaggs->plan_current || flaggs->suun_old != flaggs->suun_current)
  228.      Counter.flags |= REGEN_FLAG ;
  229.  
  230.    switch ((tb->ptr->tess >> 4) & 0x0f)  {
  231.      case FRAC_PLANET : Counter.flags |= FRACT_FLAG ;
  232.                         Counter.flags &= ~RINGW_FLAG ;
  233.                         break ;
  234.      case ELEV_PLANET : Counter.flags &= ~FRACT_FLAG ;
  235.                         Counter.flags &= ~RINGW_FLAG ;
  236.                         break ;
  237.      case FRAC_RINGWO : Counter.flags |= FRACT_FLAG ;
  238.                         Counter.flags |= RINGW_FLAG ;
  239.                         break ;
  240.      case ELEV_RINGWO : Counter.flags &= ~FRACT_FLAG ;
  241.                         Counter.flags |= RINGW_FLAG ;
  242.                         break ;
  243.      default          : break ;
  244.      }
  245.  
  246.    if (do_da_eclipse(flaggs,&tb->posit,tb->ptr->rad))
  247.      Counter.infoco = ECLPS_COLR ;
  248.  
  249.    for (dmin=1e20,i=0; i<tb->ptr->moon_count; i++)  {
  250.      tc = (t_body *) tb->next[i] ;
  251.  
  252.      calc_posit(&p,tc->ptr,&tb->posit,tb->ptr->apo) ;
  253.  
  254.      tc->posit = p ; 
  255.  
  256.      d = sqrt(p.x*p.x+p.y*p.y+p.z*p.z) ;
  257.  
  258.      tc->distan = d ;
  259.      tc->angsiz = tc->ptr->rad/d ;
  260.      tc->orbsiz = tc->ptr->orb/d ;
  261.   
  262.      if (d <= tc->ptr->rad)  {
  263.        spRingBell() ;
  264.        Counter.eye.x -= (12.0 + tc->ptr->rad - d) * p.x/d;
  265.        Counter.eye.y -= (12.0 + tc->ptr->rad - d) * p.y/d;
  266.        Counter.eye.z -= (12.0 + tc->ptr->rad - d) * p.z/d;
  267.        }
  268.  
  269.      if (tc->angsiz < ANGULAR_SIZE)  {
  270.        v.x = p.x - sptr->posit.x ;
  271.        v.y = p.y - sptr->posit.y ;
  272.        v.z = p.z - sptr->posit.z ;
  273.        D = fsqrt(v.x*v.x+v.y*v.y+v.z*v.z) ;
  274.        angle = (v.x*p.x + v.y*p.y + v.z*p.z) / (d*D) ;  
  275.        angle = 0.5 * (1.0 + angle) ;
  276.  
  277.        r = (tc->ptr->col >>  0) & 0xff ;
  278.        g = (tc->ptr->col >>  8) & 0xff ;
  279.        b = (tc->ptr->col >> 16) & 0xff ;
  280.        D = angle * tc->angsiz / ANGULAR_SIZE ;
  281.        r = (float) r * D ;
  282.        g = (float) g * D ;
  283.        b = (float) b * D ;
  284.        tc->color = 0xff000000 | (b<<16) | (g<<8) | r ;
  285.        }
  286.  
  287.      if (d < dmin)  {
  288.        dmin = d ;
  289.        flaggs->moon_current = i ;
  290.        }
  291.      }
  292.  
  293.    if (flaggs->moon_current < 0)
  294.      return;
  295.  
  296.    tc = (t_body *) tb->next[flaggs->moon_current] ;
  297.  
  298.    if (do_da_eclipse(flaggs,&tc->posit,tc->ptr->rad))
  299.      Counter.infoco = ECLPS_COLR ;
  300.  
  301.    if (Counter.star_current == 0 && flaggs->plan_current == 2)  {
  302.      p.x = 0.5*(tb->posit.x + tc->posit.x)  ;
  303.      p.y = 0.5*(tb->posit.y + tc->posit.y)  ;
  304.      p.z = 0.5*(tb->posit.z + tc->posit.z)  ;
  305.      d = sqrt(p.x*p.x+p.y*p.y+p.z*p.z) ;
  306.  
  307.      flaggs->stat.posit.x = p.x ;
  308.      flaggs->stat.posit.y = p.y ;
  309.      flaggs->stat.posit.z = p.z ;
  310.  
  311.      flaggs->stat.distan = d ;
  312.      flaggs->stat.angsiz = flaggs->stat.cliprad/d ;
  313.      }
  314. }
  315.  
  316. /**********************************************************************
  317. *  create_one()  - 
  318. ***********************************************************************/
  319. static void create_one(t_body *body,flot32 tilt)
  320.  
  321. {  FILE   *fd ;
  322.    flot32 texps[8] ;
  323.    uint32 txt[256*256] ;
  324.    sint32 a,b,i,j,obj,bytes ;
  325.    char   filename[256] ;
  326.  
  327.    body->posit.x = 0.0 ;
  328.    body->posit.y = 0.0 ;
  329.    body->posit.z = 0.0 ;
  330.    body->cliprad = 0.0 ;
  331.    body->color   = 0 ;
  332.    body->texdf   = 0 ;
  333.    body->texrn   = 0 ;
  334.    body->orbtobj[0] = 0 ;
  335.    body->orbtobj[1] = 0 ;
  336.    body->orbtobj[2] = 0 ;
  337.    body->bodyobj[0] = 0 ;
  338.    body->bodyobj[1] = 0 ;
  339.    body->bodyobj[2] = 0 ;
  340.    body->ringobj[0] = 0 ;
  341.    body->ringobj[1] = 0 ;
  342.    body->ringobj[2] = 0 ;
  343.  
  344.    a = (body->ptr->tess >> 4) & 0x0f ;
  345.    b = (body->ptr->tess     ) & 0x0f ;
  346.  
  347.    if (a == TEXX_SPHERE)  {
  348.      if (!check_data_file(body->ptr->colr)) {
  349.        printf("**ERROR**: Texture file not found: %s :Lit sphere substituted\n",datatrail(body->ptr->colr)) ;
  350.        a = LIGT_SPHERE ;
  351.        body->ptr->tess = b | (a<<4) ;
  352.        }
  353.      }
  354.    else if (a == ELEV_PLANET)  {
  355.      if (!check_data_file(body->ptr->elev)) {
  356.        printf("**ERROR**: Data file not found: %s :Lit sphere substituted\n",datatrail(body->ptr->elev)) ;
  357.        a = LIGT_SPHERE ;
  358.        body->ptr->tess = b | (a<<4) ;
  359.        }
  360.  
  361.      if (!check_data_file(body->ptr->colr)) {
  362.        printf("**ERROR**: Data file not found: %s :Lit sphere substituted\n",datatrail(body->ptr->colr)) ;
  363.        a = LIGT_SPHERE ;
  364.        body->ptr->tess = b | (a<<4) ;
  365.        }
  366.      }
  367.  
  368.    if (body->ptr->r1 != 0.0 && body->ptr->r2 != 0.0) {
  369.      if (body->ptr->ring[0] != '\0' && (fd = fopen(datatrail(body->ptr->ring),"r"))) {
  370.        fread(txt,2,256,fd) ;
  371.        fclose(fd) ;
  372.        body->texrn = spTexDef(2,256,1,txt,1);
  373.        }
  374.      else  {
  375.        printf("USER ERROR: Texture file not found: %s\n",datatrail(body->ptr->ring)) ;
  376.        exit(0) ;
  377.        }
  378.      }
  379.  
  380.    switch (a)  {
  381.  
  382.      /* v3f sphere */
  383.      case FLAT_SPHERE :
  384.                body->bodyobj[0] = generate_sphere(b  ,FLAT_SPHERE,0) ;
  385.                body->bodyobj[1] = generate_sphere(b-1,FLAT_SPHERE,0) ;
  386.                body->bodyobj[2] = generate_sphere(b-2,FLAT_SPHERE,0) ;
  387.  
  388.                if (body->ptr->r1 == 0.0 && body->ptr->r2 == 0.0)
  389.                  body->cliprad = body->ptr->rad ;
  390.                else body->cliprad = body->ptr->r2 ;
  391.                break ;
  392.  
  393.      /* n3f v3f sphere */
  394.      case LIGT_SPHERE :
  395.                body->bodyobj[0] = generate_sphere(b  ,LIGT_SPHERE,0) ;
  396.                body->bodyobj[1] = generate_sphere(b-1,LIGT_SPHERE,0) ;
  397.                body->bodyobj[2] = generate_sphere(b-2,LIGT_SPHERE,0) ;
  398.  
  399.                if (body->ptr->r1 == 0.0 && body->ptr->r2 == 0.0)
  400.                  body->cliprad = body->ptr->rad ;
  401.                else body->cliprad = body->ptr->r2 ;
  402.                break ;
  403.  
  404.      /* t2f n3f v3f sphere */
  405.      case TEXX_SPHERE : 
  406.                body->bodyobj[0] = generate_sphere(b  ,TEXX_SPHERE,body->ptr->texsz) ;
  407.                body->bodyobj[1] = generate_sphere(b-1,TEXX_SPHERE,body->ptr->texsz) ;
  408.                body->bodyobj[2] = generate_sphere(b-2,TEXX_SPHERE,body->ptr->texsz) ;
  409.  
  410.                if (body->ptr->r1 == 0.0 && body->ptr->r2 == 0.0)
  411.                  body->cliprad = body->ptr->rad ;
  412.                else body->cliprad = body->ptr->r2 ;
  413.  
  414.                for (i=0; i<already_count; i++)
  415.                  if (strcmp(already[i].name,body->ptr->colr) == 0)
  416.                    body->texdf = already[i].texdf ;
  417.  
  418.                if (body->texdf == 0)  {
  419.                  if (body->ptr->colr[0] != '\0' && (fd = fopen(datatrail(body->ptr->colr),"r"))) {
  420.                    fread(txt,4,body->ptr->texsz*body->ptr->texsz,fd) ;
  421.                    fclose(fd) ;
  422.  
  423.                    body->texdf = spTexDef(4,body->ptr->texsz,body->ptr->texsz,txt,0);
  424.                    strcpy(already[already_count].name,body->ptr->colr) ;
  425.                    already[already_count++].texdf = body->texdf;
  426.                    }
  427.                  else  {
  428.                    printf("USER ERROR: Texture file not found: %s\n",datatrail(body->ptr->colr)) ;
  429.                    exit(0) ;
  430.                    }
  431.                  }
  432.                break ;
  433.  
  434.      /* fractal planet */
  435.      case FRAC_PLANET :
  436.                if (body->ptr->r1 == 0.0 && body->ptr->r2 == 0.0)
  437.                  body->cliprad = 1.25*body->ptr->rad ;
  438.                else body->cliprad = body->ptr->r2 ;
  439.                break ;
  440.  
  441.      /* elevation field v3f planet */
  442.      case ELEV_PLANET :
  443.                if (body->ptr->r1 == 0.0 && body->ptr->r2 == 0.0)
  444.                  body->cliprad = 1.25*body->ptr->rad ;
  445.                else body->cliprad = body->ptr->r2 ;
  446.  
  447.                if (strcmp(body->ptr->elev,mem_ele_nme) == 0)
  448.                  body->land = mem_ele_ptr ;
  449.                if (strcmp(body->ptr->colr,mem_col_nme) == 0)
  450.                  body->colr = mem_col_ptr ;
  451.                break ;
  452.  
  453.      /* fractal ringworld */
  454.      case FRAC_RINGWO :
  455.                body->cliprad = 2.01*body->ptr->orb ;
  456.                break ;
  457.  
  458.      /* elevation field v3f ringworld */
  459.      case ELEV_RINGWO :
  460.                printf("Not Supported Option\n") ;
  461.                exit(0) ;
  462.                break ;
  463.  
  464.      default : printf("Not Supported Option\n") ;
  465.                exit(0) ;
  466.                break ;
  467.      }
  468.  
  469.    object_planet_orbit(body,tilt) ;
  470.  
  471.    if (body->ptr->r1 != 0.0 && body->ptr->r2 != 0.0)  {
  472.      body->ringobj[0] = object_planet_rings(body->ptr,256) ;
  473.      body->ringobj[1] = object_planet_rings(body->ptr,64) ;
  474.      body->ringobj[2] = object_planet_rings(body->ptr,16) ;
  475.      }
  476. }
  477.  
  478. /**********************************************************************
  479. *  destroy_one()  - 
  480. ***********************************************************************/
  481. static void destroy_one(t_body *body)
  482.  
  483. {  register sint32 i ;
  484.  
  485.    for (i=0; i<3; i++)  {
  486.      if (glIsList(body->orbtobj[i]))
  487.        glDeleteLists(body->orbtobj[i],1);
  488.  
  489.      if (glIsList(body->ringobj[i]))
  490.        glDeleteLists(body->ringobj[i],1);
  491.      }
  492. }
  493.  
  494. /**********************************************************************
  495. *  p_t_syst()  - 
  496. ***********************************************************************/
  497. void p_t_syst(t_system *system) 
  498.  
  499. {
  500.    printf("name   : %s\n",system->name) ;
  501.    printf("orb    : %f\n",system->orb) ;
  502.    printf("ecc    : %f\n",system->ecc) ;
  503.    printf("inc    : %f\n",system->inc) ;
  504.    printf("rad    : %f\n",system->rad) ;
  505.    printf("mas    : %f\n",system->mas) ;
  506.    printf("apo    : %f\n",system->apo) ;
  507.    printf("yer    : %f\n",system->yer) ;
  508.    printf("day    : %f\n",system->day) ;
  509.    printf("ee     : %f\n",system->ee ) ;
  510.    printf("ww     : %f\n",system->ww ) ;
  511.    printf("omega  : %f\n",system->omega) ;
  512.    printf("r1     : %f\n",system->r1 ) ;
  513.    printf("r2     : %f\n",system->r2 ) ;
  514.    printf("ring   : %s\n",system->ring) ;
  515.  
  516.    printf("moons  : %d\n",system->moon_count) ;
  517.    printf("address: %x\n",system->moons) ;
  518.    printf("\n") ;
  519.    fflush(stdout) ;
  520. }
  521.  
  522. /**********************************************************************
  523. *  p_t_body()  - 
  524. ***********************************************************************/
  525. void p_t_body(t_body *body) 
  526.  
  527. {  register sint32 i ;
  528.  
  529.    printf("Address: 0x%08x\n",body->ptr) ;
  530.    printf("Name   : %s\n",body->ptr->name) ;
  531.    printf("Where  : %f %f %f\n",body->posit.x,body->posit.y,body->posit.z) ;
  532.    printf("Angsize: %f\n",body->angsiz) ;
  533.    printf("Cliprad: %f\n",body->cliprad) ;
  534.    printf("Color  : 0x%08x\n",body->color) ;
  535.    printf("Texture: %d\n",body->texdf) ;
  536.    printf("Texture: %d\n",body->texrn) ;
  537.    printf("B Obj  : %d\n",body->bodyobj) ;
  538.    printf("O Obj  : %d\n",body->orbtobj) ;
  539.    printf("R Obj  : %d\n",body->ringobj) ;
  540.    printf("land   : 0x%08x\n",body->land) ;
  541.    printf("colr   : 0x%08x\n",body->colr) ;
  542.    printf("\n") ;
  543.    fflush(stdout) ;
  544. }
  545.  
  546. /**********************************************************************
  547. *  p_t_boss()  - 
  548. ***********************************************************************/
  549. void p_t_boss(t_boss *boss) 
  550.  
  551. {
  552.    printf("Address: 0x%08x\n",boss) ;
  553.    printf("plan_current : %d\n",boss->plan_current) ;
  554.    printf("plan_old     : %d\n",boss->plan_old) ;
  555.    printf("moon_current : %d\n",boss->moon_current) ;
  556.    printf("moon_old     : %d\n",boss->moon_old) ;
  557.    fflush(stdout) ;
  558.  
  559.    p_t_body(&boss->stat) ;
  560.  
  561.    p_t_body(&boss->star[0]) ;
  562.    p_t_syst(boss->star[0].ptr) ;
  563. }
  564.  
  565. /**********************************************************************
  566. *  generate_solar_system()  -
  567. ***********************************************************************/
  568. static void generate_solar_system(t_boss *flaggs,sint32 index,t_stars *s)
  569.  
  570. {  register t_system *xxx,*yyy,*zzz,*y,*z ;
  571.             flot32   temp ;
  572.    register sint32   i,j,k,*pp = (sint32 *)&temp,suction ;
  573.    register flot32   apo[2],rad[2],q,f,temperature ;
  574.    register flot64   mas[2];
  575.    register char     ch[32] ;
  576.    register C3       b ;
  577.  
  578.    flaggs->suncount = 1;
  579.    flaggs->star[0].ptr = NULL;
  580.    flaggs->star[1].ptr = NULL;
  581.  
  582.    if (Counter.z == SOL_Z_GRID && Counter.x == SOL_X_GRID && index == 0) {
  583.      flaggs->star[0].ptr = &solsys;
  584.      create_one(&flaggs->star[0],0.0);
  585.      return;
  586.      }
  587.    else if ((index%100) == 14) {
  588.      flaggs->star[0].ptr = generate_ringworld_system(index,s) ;
  589.      create_one(&flaggs->star[0],0.0);
  590.      return;
  591.      }
  592.  
  593.    temp = s->x + s->y + s->z;
  594.    srand(*pp) ;
  595.    rand() ;
  596.    suction = rand() & 1;
  597.  
  598.    flaggs->suncount = ((s->abs_mag2 == 0.0 && s->scass2 == 0.0) ? 1 : 2);
  599.  
  600.    for (k=0; k<flaggs->suncount; k++)  {
  601.      if ((xxx = (t_system *)malloc(sizeof(t_system))) == 0)  {
  602.        printf("ERROR: solar system generation malloc failed\n") ;
  603.        exit(0) ;
  604.        }
  605.      flaggs->star[k].ptr = xxx;
  606.      }
  607.  
  608.    star_params(s,apo,rad,mas) ;
  609.  
  610.    for (k=0; k<flaggs->suncount; k++)  {
  611.      xxx = flaggs->star[k].ptr;
  612.  
  613.      if (Counter.z == SOL_Z_GRID && Counter.x == SOL_X_GRID)  {
  614.        if (!strcmp(StarName[index],""))  {
  615.          sprintf(ch,"%d-%d,%d",index,Counter.x,Counter.z) ;
  616.          strcpy(xxx->name,ch) ;
  617.          }
  618.        else strcpy(xxx->name,StarName[index]) ;
  619.        }
  620.      else  {
  621.        sprintf(ch,"%d-%d,%d",index,Counter.x,Counter.z) ;
  622.        strcpy(xxx->name,ch) ;
  623.        }
  624.  
  625.      xxx->apo = apo[k];
  626.      xxx->rad = rad[k];
  627.      xxx->mas = mas[k];
  628.  
  629.      if (flaggs->suncount == 2)  {
  630.        xxx->ecc = 0.75*float_rand();
  631.        xxx->inc = 45.0*(float_rand() - 0.5);
  632.        }
  633.      else  {
  634.        xxx->ecc = 0.0;
  635.        xxx->inc = 0.0;
  636.        }
  637.  
  638.      xxx->orb     = 0.0;
  639.      xxx->yer     = 9.0;
  640.      xxx->day     = 1.0 ;
  641.      xxx->ee      = 0.0 ;
  642.      xxx->ww      = 0.0 ;
  643.      xxx->omega   = 0.0 ;
  644.      xxx->r1      = 0.0 ;
  645.      xxx->r2      = 0.0 ;
  646.      xxx->ring[0] = '\0' ;
  647.  
  648.      if (k == 1)  {
  649.        if (s->scass2 < 0.10)  {
  650.          b.r = 1.00 ; b.g = 0.00 ; b.b = 0.00 ;
  651.          }
  652.        else if (s->scass2 < 0.28)  {
  653.          b.r = 1.00 ; b.g = 0.50 ; b.b = 1.00 ;
  654.          }
  655.        else if (s->scass2 < 0.37)  {
  656.          b.r = 1.00 ; b.g = 1.00 ; b.b = 0.00 ;
  657.          }
  658.        else if (s->scass2 < 0.45)  {
  659.          b.r = 0.50 ; b.g = 1.00 ; b.b = 1.00 ;
  660.          }
  661.        else if (s->scass2 < 0.58)  {
  662.          b.r = 0.00 ; b.g = 1.00 ; b.b = 0.00 ;
  663.          }
  664.        else if (s->scass2 < 0.89)  {
  665.          b.r = 0.00 ; b.g = 1.00 ; b.b = 0.50 ;
  666.          }
  667.        else {
  668.          b.r = 0.00 ; b.g = 0.00 ; b.b = 1.00 ;
  669.          }
  670.        xxx->col = 0xff000000 | ((sint32)(b.b*255.0)<<16) | ((sint32)(b.g*255.0)<<8) | (sint32)(b.r*255.0);
  671.        }
  672.      else  {
  673.        xxx->col = 0xff000000|((sint32)(s->b*255.0)<<16) | ((sint32)(s->g*255.0)<<8) | (sint32)(s->r*255.0);
  674.        }
  675.  
  676.      xxx->tess    = 3 ;
  677.      xxx->texsz   = 0 ;
  678.      xxx->scale   = 0.0 ;
  679.      xxx->lxsize  = 0 ;
  680.      xxx->lysize  = 0 ;
  681.      xxx->lformat = 0 ;
  682.      xxx->elev[0] = '\0' ;
  683.      xxx->cxsize  = 0 ;
  684.      xxx->cysize  = 0 ;
  685.      xxx->cformat = 0 ;
  686.      xxx->colr[0] = '\0' ;
  687.  
  688.      if (suction && flaggs->suncount == 2)
  689.        xxx->moon_count = 0;
  690.      else xxx->moon_count = (3*(rand() & 0xf))>>2 ;
  691.      xxx->moons = NULL ;
  692.  
  693.      create_one(&flaggs->star[k],0.0);
  694.  
  695.      if (xxx->moon_count > 0)  {
  696.        if ((yyy = (t_system *)malloc(xxx->moon_count*sizeof(t_system))) == 0)  {
  697.          printf("ERROR: planet system generation malloc failed\n") ;
  698.          exit(0) ;
  699.          }
  700.  
  701.        xxx->moons = yyy ;
  702.   
  703.        for (y=yyy,i=0; i<xxx->moon_count; y++,i++)  {
  704.          y->name[0] = i + 'A' ;
  705.          y->name[1] = '\0' ;
  706.   
  707.          if (i==0)
  708.            y->orb    = xxx->rad + 100000000.0 ;
  709.          else y->orb = 2.0*(y-1)->orb - 0.4*AUTOKM ;
  710.   
  711.          y->ecc     = 0.1*float_rand() ;
  712.          y->inc     = xxx->inc + 90.0*(float_rand() - 0.5)*(float_rand() - 0.5) ;
  713.          y->rad     = 1000.0 + rand() ;
  714.          y->mas     = 1.0e25 ;
  715.          y->apo     = float_rand() ; y->apo = 90.0*(y->apo * y->apo * y->apo) ;
  716.          y->yer     = newton(y->orb,xxx->mas+y->mas) ;
  717.          y->day     = 0.5 + (rand() & 0x0f) ;
  718.          y->ee      = rand() & 0x01ff ;
  719.          y->ww      = rand() & 0x01ff ;
  720.          y->omega   = rand() & 0x01ff ;
  721.          y->r1      = 0.0 ;
  722.          y->r2      = 0.0 ;
  723.   
  724.          if ((rand() & 0x7) == 0)  {
  725.            y->r1 = 1.2 * y->rad ;
  726.            y->r2 = 2.0 * y->rad ;
  727.            strcpy(y->ring,"saturn.ring") ;
  728.            }
  729.  
  730.          /* earth type temperature ? */
  731.          f = (xxx->rad * xxx->rad * xxx->apo * 150.0) / (7000.0 * 7000.0 * 55.0 * y->orb) ;
  732.   
  733.          if (f > 0.8 && f < 1.25)  {
  734.            y->tess = 0x30 ;
  735.            y->apo *= 0.25 ;
  736.            spRingBell() ;
  737.            }
  738.          else y->tess = 0x14 ;
  739.   
  740.          y->col     = generate_full_color() ;
  741.          y->texsz   = 0 ;
  742.          y->scale   = 0.0 ;
  743.          y->lxsize  = 0 ;
  744.          y->lysize  = 0 ;
  745.          y->lformat = 0 ;
  746.          y->elev[0] = '\0' ;
  747.          y->cxsize  = 0 ;
  748.          y->cysize  = 0 ;
  749.          y->cformat = 0 ;
  750.          y->colr[0] = '\0' ;
  751.          y->moon_count = 12.0 * float_rand() * float_rand() ;
  752.          y->moons = NULL ;
  753.   
  754.          if (y->tess == 0x30)
  755.            y->moon_count++ ;
  756.   
  757.          if (y->moon_count > 0)  {
  758.            if ((zzz = (t_system *)malloc(y->moon_count*sizeof(t_system))) == 0)  {
  759.              printf("ERROR: planet system generation malloc failed\n") ;
  760.              exit(0) ;
  761.              }
  762.  
  763.            y->moons = zzz ;
  764.  
  765.            for (z=zzz,j=0; j<y->moon_count; z++,j++)  {
  766.              z->name[0] = j + 'a' ;
  767.              z->name[1] = '\0' ;
  768.   
  769.              z->orb     = y->rad + (j+1) * 100000.0 ;
  770.   
  771.              z->ecc     = 0.2*float_rand() ;
  772.              z->inc     = 180.0*(float_rand() - 0.5)*(float_rand() - 0.5) ;
  773.              z->rad     = 100.0 + (rand() >> 3) ;
  774.              z->mas     = 1.0e22 ;
  775.              z->apo     = 0.0 ;
  776.              z->yer     = newton(z->orb,y->mas+z->mas) ;
  777.              z->day     = z->yer ;
  778.              z->ee      = rand() & 0x01ff ;
  779.              z->ww      = rand() & 0x01ff ;
  780.              z->omega   = rand() & 0x01ff ;
  781.              z->r1      = 0.0 ;
  782.              z->r2      = 0.0 ;
  783.   
  784.              z->col     = generate_full_color() ;
  785.              z->tess    = 0x13 ;
  786.              z->texsz   = 0 ;
  787.              z->scale   = 0.0 ;
  788.              z->lxsize  = 0 ;
  789.              z->lysize  = 0 ;
  790.              z->lformat = 0 ;
  791.              z->elev[0] = '\0' ;
  792.              z->cxsize  = 0 ;
  793.              z->cysize  = 0 ;
  794.              z->cformat = 0 ;
  795.              z->colr[0] = '\0' ;
  796.   
  797.              z->moon_count = 0 ;
  798.              z->moons = NULL ;
  799.              }
  800.            }
  801.          }
  802.        }
  803.      }
  804.  
  805.    if (flaggs->suncount == 2)  {
  806.      double m = flaggs->star[0].ptr->mas + flaggs->star[1].ptr->mas ;
  807.      double n = flaggs->star[0].ptr->mas / flaggs->star[1].ptr->mas ;
  808.  
  809.      if (suction)  {
  810.        flaggs->star[0].ptr->orb = (2.0 + 6.0*float_rand()) * flaggs->star[0].ptr->rad;
  811.        flaggs->star[1].ptr->orb = (2.0 + 6.0*float_rand()) * flaggs->star[1].ptr->rad;
  812.  
  813.        if (flaggs->star[0].ptr->ecc < 0.35)
  814.          flaggs->star[0].ptr->ecc *= 2.0;
  815.        }
  816.      else  {
  817.        q = 1.0e9*float_rand();
  818.        if (flaggs->star[0].ptr->moon_count > 0) {
  819.          xxx = flaggs->star[0].ptr->moons;
  820.          xxx += flaggs->star[0].ptr->moon_count-1;
  821.          q += xxx->orb;
  822.          }
  823.        if (flaggs->star[1].ptr->moon_count > 0) {
  824.          yyy = flaggs->star[1].ptr->moons;
  825.          yyy += flaggs->star[1].ptr->moon_count-1;
  826.          q += yyy->orb;
  827.          }
  828.  
  829.        flaggs->star[0].ptr->orb = 1.0e6*float_rand();
  830.        flaggs->star[1].ptr->orb = flaggs->star[0].ptr->orb * n;
  831.  
  832.        while (flaggs->star[0].ptr->orb < q || flaggs->star[1].ptr->orb < q)  {
  833.          flaggs->star[0].ptr->orb += flaggs->star[0].ptr->orb;
  834.          flaggs->star[1].ptr->orb += flaggs->star[0].ptr->orb * n;
  835.          }
  836.        }
  837.  
  838.      flaggs->star[1].ptr->ecc = flaggs->star[0].ptr->ecc;
  839.      flaggs->star[1].ptr->orb = -flaggs->star[1].ptr->orb;
  840.      flaggs->star[0].ptr->yer = newton(flaggs->star[0].ptr->orb,m) ;
  841.      flaggs->star[1].ptr->yer = flaggs->star[0].ptr->yer;
  842.      }
  843. }
  844.  
  845. /**********************************************************************
  846. *  generate_full_color()  -
  847. ***********************************************************************/
  848. static uint32 generate_full_color(void) 
  849.  
  850. {  uint32 r,g,b,max ;
  851.  
  852.    r = rand() & 0xff ;
  853.    g = rand() & 0xff ;
  854.    b = rand() & 0xff ;
  855.  
  856.    if (r >= g && r >= b) max = r ;
  857.    if (g >= b && g >= r) max = g ;
  858.    if (b >= r && b >= g) max = b ;
  859.  
  860.    r = (r * 255) / max ;
  861.    g = (g * 255) / max ;
  862.    b = (b * 255) / max ;
  863.  
  864.    return(0xff000000 | (b<<16) | (g<<8) | r) ;
  865. }
  866.  
  867. /**********************************************************************
  868. *  do_da_eclipse()  -
  869. ***********************************************************************/
  870. static sint32 do_da_eclipse(t_boss *flaggs,D3 *p,flot32 r) 
  871.  
  872. {  register V3     v ;
  873.    register D3     *sun ;
  874.    register P3     c ;
  875.    register flot32 R,d,D,t,w,f,g ;
  876.  
  877.    R = flaggs->star[flaggs->suun_current].ptr->rad ;
  878.    sun = &flaggs->star[flaggs->suun_current].posit ;
  879.  
  880.    v.x = p->x - sun->x ; 
  881.    v.y = p->y - sun->y ; 
  882.    v.z = p->z - sun->z ; 
  883.    D = fsqrt(v.x*v.x + v.y*v.y + v.z*v.z) ;
  884.    v.x /= D ; 
  885.    v.y /= D ; 
  886.    v.z /= D ; 
  887.  
  888.    d = r*D/(R-r) ;
  889.  
  890.    t = -v.x*p->x -v.y*p->y -v.z*p->z ;
  891.  
  892.    if (t <= 0.0 || t >= d)  {
  893.      if (!(Counter.flags & ECLIP_FLAG))
  894.        Counter.feclipse = 0.0 ;
  895.      return(0) ;
  896.      }
  897.  
  898.    c.x = p->x + t * v.x ;
  899.    c.y = p->y + t * v.y ;
  900.    c.z = p->z + t * v.z ;
  901.  
  902.    f = r*(d-t)/d ;
  903.    g = (r+R)*(t+D)/D - R;
  904.  
  905.    w = c.x*c.x + c.y*c.y + c.z*c.z ;
  906.  
  907.    if (w > g*g)  {
  908.      if (!(Counter.flags & ECLIP_FLAG))
  909.        Counter.feclipse = 0.0 ;
  910.      return(0) ;
  911.      }
  912.    else if (w < f*f) {
  913.      Counter.flags |= ECLIP_FLAG ;
  914.      Counter.feclipse = 1.0 ;
  915.      return(1) ;
  916.      }
  917.    else  {
  918.      Counter.flags |= ECLIP_FLAG ;
  919.      w = fsqrt(w) ;
  920.      t = (w-g)/(f-g) ;
  921.      Counter.feclipse = t*t ;
  922.      return(1) ;
  923.      }
  924. }
  925.  
  926. /**********************************************************************
  927. *  generate_ringworld_system()  -
  928. ***********************************************************************/
  929. static t_system *generate_ringworld_system(register sint32 index,t_stars *s)
  930.  
  931. {  register t_system *xxx,*yyy ;
  932.    register char     ch[32] ;
  933.  
  934.    if ((xxx = (t_system *)malloc(sizeof(t_system))) == 0)  {
  935.      printf("ERROR: solar system generation malloc failed\n") ;
  936.      exit(0) ;
  937.      }
  938.  
  939.    if (Counter.z == SOL_Z_GRID && Counter.x == SOL_X_GRID)  {
  940.      if (!strcmp(StarName[index],""))  {
  941.        sprintf(ch,"%d-%d,%d",index,Counter.x,Counter.z) ;
  942.        strcpy(xxx->name,ch) ;
  943.        }
  944.      else strcpy(xxx->name,StarName[index]) ;
  945.      }
  946.    else  {
  947.      sprintf(ch,"%d-%d,%d",index,Counter.x,Counter.z) ;
  948.      strcpy(xxx->name,ch) ;
  949.      }
  950.  
  951.    xxx->orb     = 5500.0 ;
  952.    xxx->ecc     = 0.0 ;
  953.    xxx->inc     = 0.0 ;
  954.    xxx->rad     = 700000.0;
  955.    xxx->mas     = 2.0e30 ;
  956.    xxx->apo     = 0.0 ;
  957.    xxx->yer     = 9.0 ;
  958.    xxx->day     = 1.0 ;
  959.    xxx->ee      = 0.0 ;
  960.    xxx->ww      = 0.0 ;
  961.    xxx->omega   = 0.0 ;
  962.    xxx->r1      = 0.0 ;
  963.    xxx->r2      = 0.0 ;
  964.    xxx->ring[0] = '\0' ;
  965.  
  966.    xxx->col     = 0xff00ffff ;
  967.    xxx->tess    = 3 ;
  968.    xxx->texsz   = 0 ;
  969.    xxx->scale   = 0.0 ;
  970.    xxx->lxsize  = 0 ;
  971.    xxx->lysize  = 0 ;
  972.    xxx->lformat = 0 ;
  973.    xxx->elev[0] = '\0' ;
  974.    xxx->cxsize  = 0 ;
  975.    xxx->cysize  = 0 ;
  976.    xxx->cformat = 0 ;
  977.    xxx->colr[0] = '\0' ;
  978.  
  979.    if ((yyy = (t_system *)malloc(sizeof(t_system))) == 0)  {
  980.      printf("ERROR: planet system generation malloc failed\n") ;
  981.      exit(0) ;
  982.      }
  983.  
  984.    xxx->moon_count = 1 ;
  985.    xxx->moons = yyy ;
  986.  
  987.    strcpy(yyy->name,"Ringworld") ;
  988.    yyy->orb     = 152800000.0 ;
  989.    yyy->ecc     = 0.0 ;
  990.    yyy->inc     = 0.0 ;
  991.    yyy->rad     = 0.0 ;
  992.    yyy->mas     = 2.0e27 ;
  993.    yyy->apo     = 0.0 ;
  994.    yyy->yer     = 9.037 ;
  995.    yyy->day     = 0.0 ;
  996.    yyy->ee      = 0.0 ;
  997.    yyy->ww      = 0.0 ;
  998.    yyy->omega   = 0.0 ;
  999.    yyy->r1      = 0.0 ;
  1000.    yyy->r2      = 0.0 ;
  1001.    yyy->ring[0] = '\0' ;
  1002.  
  1003.    yyy->col     = 0xff00ffff ;
  1004.    yyy->tess    = 0x54 ;
  1005.    yyy->texsz   = 0 ;
  1006.    yyy->scale   = 0.0 ;
  1007.    yyy->lxsize  = 0 ;
  1008.    yyy->lysize  = 0 ;
  1009.    yyy->lformat = 0 ;
  1010.    yyy->elev[0] = '\0' ;
  1011.    yyy->cxsize  = 0 ;
  1012.    yyy->cysize  = 0 ;
  1013.    yyy->cformat = 0 ;
  1014.    yyy->colr[0] = '\0' ;
  1015.  
  1016.    yyy->moon_count = 0 ;
  1017.    yyy->moons      = NULL ;
  1018.  
  1019.    return(xxx) ;
  1020. }
  1021.  
  1022. /**********************************************************************
  1023. *  star_params()  - 
  1024. **********************************************************************/
  1025. void star_params(t_stars *st,flot32 *temp,flot32 *radi,flot64 *mass)
  1026.  
  1027. {  register sint32 i ;
  1028.    register flot32 r,g,b,a ;
  1029.    register char   cs[4] ;
  1030.  
  1031.    st->a = 1.00 ;
  1032.    *temp =   2500.0 * fexp(flog(fsqrt(2.0)) * 7.0 * st->scass) ; 
  1033.    *radi = fexp(flog(10.0) * (10.0 - 14.0*st->scass - st->abs_mag)/5.0) ;
  1034.    *mass = 2.0e30 * (*radi) * (*radi) * (*radi) ;
  1035.    *radi *= 700000.0 ;
  1036.  
  1037.    *(temp+1) =   2500.0 * fexp(flog(fsqrt(2.0)) * 7.0 * st->scass2) ; 
  1038.    *(radi+1) = fexp(flog(10.0) * (10.0 - 14.0*st->scass2 - st->abs_mag2)/5.0) ;
  1039.    *(mass+1) = 2.0e30 * (*(radi+1)) * (*(radi+1)) * (*(radi+1)) ;
  1040.    *(radi+1) *= 700000.0 ;
  1041.  
  1042.    if (st->scass < 0.10)  {
  1043.      cs[0] = 'M' ; 
  1044.      i = 10.0 * (0.10 - st->scass)/0.10 ;
  1045.      cs[1] = '0' + i ; 
  1046.      st->r = 1.00 ; st->g = 0.00 ; st->b = 0.00 ;
  1047.      }
  1048.    else if (st->scass < 0.28)  {
  1049.      cs[0] = 'K' ; 
  1050.      i = 10.0 * (0.28 - st->scass)/0.18 ;
  1051.      cs[1] = '0' + i ; 
  1052.      st->r = 1.00 ; st->g = 0.50 ; st->b = 1.00 ;
  1053.      }
  1054.    else if (st->scass < 0.37)  {
  1055.      cs[0] = 'G' ; 
  1056.      i = 10.0 * (0.37 - st->scass)/0.09 ;
  1057.      cs[1] = '0' + i ; 
  1058.      st->r = 1.00 ; st->g = 1.00 ; st->b = 0.00 ;
  1059.      }
  1060.    else if (st->scass < 0.45)  {
  1061.      cs[0] = 'F' ; 
  1062.      i = 10.0 * (0.45 - st->scass)/0.08 ;
  1063.      cs[1] = '0' + i ; 
  1064.      st->r = 0.50 ; st->g = 1.00 ; st->b = 1.00 ;
  1065.      }
  1066.    else if (st->scass < 0.58)  {
  1067.      cs[0] = 'A' ; 
  1068.      i = 10.0 * (0.58 - st->scass)/0.13 ;
  1069.      cs[1] = '0' + i ; 
  1070.      st->r = 0.00 ; st->g = 1.00 ; st->b = 0.00 ;
  1071.      }
  1072.    else if (st->scass < 0.89)  {
  1073.      cs[0] = 'B' ; 
  1074.      i = 10.0 * (0.89 - st->scass)/0.31 ;
  1075.      cs[1] = '0' + i ; 
  1076.      st->r = 0.00 ; st->g = 1.00 ; st->b = 0.50 ;
  1077.      }
  1078.    else {
  1079.      cs[0] = 'O' ; 
  1080.      i = 10.0 * (1.00 - st->scass)/0.11 ;
  1081.      cs[1] = '0' + i ; 
  1082.      st->r = 0.00 ; st->g = 0.00 ; st->b = 1.00 ;
  1083.      }
  1084.  
  1085.    if (Counter.flags & NDPNT_FLAG)  {
  1086.      st->r  = 1.0 ; st->g  = 1.0 ; st->b  = 1.0 ;
  1087.      }
  1088. }
  1089.  
  1090. /**********************************************************************
  1091. *  newton()  - 
  1092. **********************************************************************/
  1093. static flot64 newton(register flot64 orb, register flot64 mas)
  1094.  
  1095. {  
  1096.    return(sqrt(orb*orb*orb*4.0*M_PI*M_PI/(GRAV*mas)) / (24.0*3600.0)) ;
  1097. }
  1098.  
  1099. /**********************************************************************
  1100. *  float_rand()  - 
  1101. **********************************************************************/
  1102. flot32 float_rand(void)
  1103.  
  1104. {           sint32 temp ;
  1105.    register flot32 *fd = (flot32 *)&temp ;
  1106.  
  1107.    temp = 0x3f800000 | (rand() << 8) ;
  1108.  
  1109.    return(*fd - 1.0) ;
  1110. }
  1111.  
  1112. /**********************************************************************
  1113. *  calculate_orbital_params()  -
  1114. **********************************************************************/
  1115. void calculate_orbital_params(D3 *bd,flot32 GMm,t_system *myorb)
  1116.  
  1117. {  P4     r,c ;
  1118.    V3     v ;
  1119.    flot32 inc,ome,uuu,a,ecc,p,vel,E,V,q,M,n,t,tt ;
  1120.  
  1121.    vel = Counter.S ;
  1122.    v.x = Counter.vnorm.x * vel ;
  1123.    v.y = Counter.vnorm.y * vel ;
  1124.    v.z = Counter.vnorm.z * vel ;
  1125.  
  1126.    r.x = -bd->x ; 
  1127.    r.y = -bd->y ; 
  1128.    r.z = -bd->z ; 
  1129.    r.w = fsqrt(r.x*r.x + r.y*r.y + r.z*r.z) ;
  1130.  
  1131.    c.x = r.y*v.z - r.z*v.y ; 
  1132.    c.y = r.z*v.x - r.x*v.z ; 
  1133.    c.z = r.x*v.y - r.y*v.x ; 
  1134.    c.w = fsqrt(c.x*c.x + c.y*c.y + c.z*c.z) ;
  1135.  
  1136.    inc = fatan2(fsqrt(c.x*c.x+c.y*c.y),c.z) ;
  1137.    ome = fatan2(c.x,-c.y) ;
  1138.    uuu = fatan2(-bd->x*fcos(ome)-bd->y*fsin(ome),-bd->z/fsin(inc)) ;
  1139.  
  1140.    a = 2.0/r.w - vel*vel/GMm ;  
  1141.  
  1142.    p = c.w*c.w/GMm ;
  1143.    ecc = fsqrt(1.0 - p*a) ;
  1144.    q = p/(1.0+ecc) ;
  1145.  
  1146.    /* elliptic */
  1147.    if (a > 0.0)  {
  1148.      E = fatan2(1.0-r.w*a,(r.x*v.x + r.y*v.y + r.z*v.z)/fsqrt(a*GMm)) ;
  1149.      V = 2.0*fatan(sqrt((1+ecc)/(1-ecc))*ftan(0.5*E)) ;
  1150.  
  1151.      M = E - ecc*fsin(E) ;
  1152.      n = fsqrt(GMm*a*a*a) ;
  1153.      t = M/n ;
  1154.      }
  1155.  
  1156.    /* hyperbolic */
  1157.    else if (a < 0.0)  {
  1158.      E = asinh((r.x*v.x + r.y*v.y + r.z*v.z) / (ecc*fsqrt(2.0*GMm/-a))) ;
  1159.      V = 2.0*fatan(fsqrt((ecc+1)/(ecc-1))*ftanh(0.5*E)) ;
  1160.  
  1161.      t = fsqrt(1.0/(GMm*a*a*a)) * (ecc*fsinh(E) - E) ;
  1162.      }
  1163.  
  1164.    /* parabolic */
  1165.    else  {
  1166.      n = (r.x*v.x + r.y*v.y + r.z*v.z) / fsqrt(2.0*q*GMm) ;
  1167.  
  1168.      t = q * fsqrt(2.0*q/GMm) * (n*n*n/3.0 + n) ;
  1169.      }
  1170.  
  1171.    tt = Counter.D - t/(24.0*3600.0) ;
  1172.  
  1173.    myorb->orb   = 1.0/a ;
  1174.    myorb->ecc   = ecc ;
  1175.    myorb->inc   = inc*RTOD ;
  1176.    myorb->ee    = tt ;
  1177.    myorb->ww    = (uuu - V + ome)*RTOD ;
  1178.    myorb->omega = ome*RTOD ;
  1179.    myorb->yer   = fsqrt(4.0*M_PI*M_PI/(GMm*a*a*a)) ;
  1180.    myorb->day   = 1.0 ;
  1181. }
  1182.  
  1183. /**********************************************************************
  1184. *  check_data_file()  -
  1185. **********************************************************************/
  1186. static long check_data_file(char *name)
  1187.  
  1188. {  FILE *fd;
  1189.  
  1190.    if (fd = fopen(datatrail(name),"r")) {
  1191.      fclose(fd);
  1192.      return(1);
  1193.      }
  1194.    else  {
  1195.      char str[256];
  1196.  
  1197.      strcpy(str,datatrail(name));
  1198.      strcat(str,".Z");
  1199.  
  1200.      if (fd = fopen(str,"r")) {
  1201.        fclose(fd);
  1202.  
  1203.        strcpy(str,"/usr/bsd/uncompress ");
  1204.        strcat(str,datatrail(name));
  1205.        strcat(str,".Z");
  1206.  
  1207.        return(!system(str));
  1208.        }
  1209.  
  1210.      return(0);
  1211.      }
  1212. }
  1213.  
  1214.